﻿using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using Sinacor.Infra.Service.Validation;
using Sinacor.Infra.Service.Common;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Service.ExceptionHandling;
using Sinacor.Infra.Service.Validation.BusinessRules;
using Sinacor.Infra.Service.Security.Authorization;

namespace Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessLogic.BusinessRulesValidation
{

	/// <summary>
	/// Valida inclusão de Ordem <b>BusinessEntity.Ordem</b>
	/// </summary>
    public class ValidadorInclusaoOrdem : BaseBusinessRuleValidation<BusinessEntity.Ordem>, IBusinessRuleValidation
    {

        Movimento.BusinessEntity.InformacoesMovimento _informacoesMovimento;

        #region Properties

        /// <summary>
		/// armazena dados do ativo da ordem a ser validada
		/// </summary>
		private Titulo.BusinessEntity.Titulo _ativo;
		
        /// <summary>
		/// armazena dados do cliente da ordem a ser validada
		/// </summary>
		private Cliente.BusinessEntity.Cliente _cliente;

        #endregion

        #region Constructor

        public ValidadorInclusaoOrdem(){ }

        #endregion

        #region Methods

        /// <summary>
		/// Verificar o diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ConfigurarOrdem()
		/// </summary>
		private void ConfigurarOrdem()
        {
            EntityToValidate.Situacao = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.SituacaoOrdem.Demais;
            EntityToValidate.NumeroOrdemSubSequencia = 0;
            EntityToValidate.CodigoUsuario = AuthorizationContext.Current.UserId;

            EntityToValidate.DataHoraOrdem = new DateTime(_informacoesMovimento.DataMovimento.Year, _informacoesMovimento.DataMovimento.Month,
                _informacoesMovimento.DataMovimento.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);

            EntityToValidate.DataOrdem = _informacoesMovimento.DataMovimento;

            if (EntityToValidate.IndicadorLiquidacaoExterna.HasValue)
            {
                if (EntityToValidate.IndicadorDesprezaSaldo.HasValue)
                {
                    EntityToValidate.NumeroOrdemOriginal = 0;
                }
                else
                {
                    EntityToValidate.IndicadorDesprezaSaldo = false;
                    EntityToValidate.NumeroOrdemOriginal = 0;
                }
            }
            else
            {
                EntityToValidate.IndicadorLiquidacaoExterna = false;

                if (EntityToValidate.IndicadorDesprezaSaldo.HasValue)
                {
                    EntityToValidate.NumeroOrdemOriginal = 0;
                }
                else
                {
                    EntityToValidate.IndicadorDesprezaSaldo = false;
                    EntityToValidate.NumeroOrdemOriginal = 0;
                }

            }

            EntityToValidate.TimeStampInterna = new Calendario.BusinessLogic.Calendario().ObterTimeStamp();

            EntityToValidate.IndicadorGravaLog = false;

            EntityToValidate.QuantidadeExecutada = 0;

            EntityToValidate.IndicadorCasaOrdem = true;

            EntityToValidate.Distribuida = false;

            EntityToValidate.QuantidadeCanceladaOferta = 0;

        }

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ConfigurarTipoDistribuicao()
		/// </summary>
		private void ConfigurarTipoDistribuicao()
        {
            if (_cliente.IsAdministradoConcorrente)
            {
                if (!String.IsNullOrEmpty(EntityToValidate.CodigoISIN) 
                    && EntityToValidate.CodigoISIN.Substring(6, 2).ToUpper() == "PP")
                {
                    base.AddValidationError(109320);
                }
                else
                {
                    EntityToValidate.TipoDistribuicaoPermitida = 
                        Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoDistribuicaoPermitida.DiferenciadoAdministradoConcorrente;
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(EntityToValidate.CodigoISIN) 
                    && EntityToValidate.CodigoISIN.Substring(6, 2).ToUpper() == "PP")
                {
                    EntityToValidate.TipoDistribuicaoPermitida =
                        Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoDistribuicaoPermitida.DiferenciadoPOP;
                }
                else
                {
                    EntityToValidate.TipoDistribuicaoPermitida =
                        Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoDistribuicaoPermitida.Normal;
                }
            }
		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ConfigurarTipoLiquidacao()
		/// </summary>
		private void ConfigurarTipoLiquidacao()
        {
            if (new Parametro.BusinessLogic.Parametro().ObterParametro().TipoLiquidacaoCAutomatica)
            {
                Cliente.BusinessEntity.AgenteCustodia age = new Cliente.BusinessLogic.Cliente().ConsultarAgenteCustodia
                    (
                    new Cliente.BusinessEntity.Parameter.ConsultarClientePorCodigo() { CodigoCliente = _cliente.Codigo.Value }
                    );

                if (age.CodigoCustodiante.HasValue)
                {
                    if (
                            (
                                EntityToValidate.Mercado == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoCompra 
                                || 
                                EntityToValidate.Mercado == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoVenda  
                                || 
                                EntityToValidate.Mercado == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Termo       
                                || 
                                EntityToValidate.Mercado == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Futuro
                            )
                                || 
                                (EntityToValidate.CodigoISIN.Substring(6, 2).ToUpper() == "PP")
                        )
                    {
                        EntityToValidate.TipoLiquidacao = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoLiquidacao.Custodiante;
                    }
                    else
                    {
                        EntityToValidate.TipoLiquidacao = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoLiquidacao.Normal;
                    }
                }
                else
                { 
                    Cliente.BusinessEntity.UsuarioInstitucional usu = new Cliente.BusinessLogic.Cliente().ConsultarUsuarioInstitucional
                    (
                    new Cliente.BusinessEntity.Parameter.ConsultarClientePorCodigo() { CodigoCliente = _cliente.Codigo.Value }
                    );

                    if (usu.CodigoUsuarioInstitucional.HasValue)
                    {
                        if ((
                                                                                                                   EntityToValidate.Mercado ==
                            Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoCompra || EntityToValidate.Mercado ==
                            Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoVenda || EntityToValidate.Mercado ==
                            Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Termo || EntityToValidate.Mercado ==
                            Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Futuro
                            ) || (EntityToValidate.CodigoISIN.Substring(6, 2).ToUpper() == "PP"))
                        { 
                            EntityToValidate.TipoLiquidacao = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoLiquidacao.Custodiante; 
                        }
                        else
                        { 
                            EntityToValidate.TipoLiquidacao = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoLiquidacao.Normal;      
                        }

                    }
                    else
                    {
                        EntityToValidate.TipoLiquidacao = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoLiquidacao.Normal;
                    }

                }
                
            }
		}

		/// <summary>
		/// retornar <b>base</b>.ErrorsList
		/// </summary>
		public List<Infra.Common.Validation.ValidationError> GetErrors()
        {
            return base.ErrorsList;
		}

		/// <summary>
		/// <b>Se</b> request.Argumentos é igual a nulo ou vazio
		/// base.AddValidationError() passando o código do erro que está no objeto request
		/// (BusinessEntity.Resultado.CodigoErro)
		/// <b>Senão</b>
		///   Utilizar o método <font
		/// color="#2b91af">ErrorMessage</font>().ConvertXmlArgumentsToParameters(request.
		/// Argumentos), para traduzir o xml em objetos.
		/// base.AddValidationError() passando o código do erro e os argumentos traduzidos.
		/// 
		/// <b>Fim Se
		/// </b>
		/// </summary>
		/// <param name="request"></param>
		private void TratarExcecoes(BusinessEntity.Resultado request)
        {
            if (string.IsNullOrEmpty(request.Argumentos))
                
               this.AddValidationError( request.CodigoErro);

            else
            {

                string mensagem = string.Empty;
                string resourceKey = string.Empty;
                ErrorMessage errormessage = new ErrorMessage();
                mensagem = ErrorMessage.RetrieveErrorMessage(request.CodigoErro, out resourceKey);
                List<object> itens = ErrorMessage.ConvertXmlArgumentsToParameters(request.Argumentos);
                base.AddValidationError(request.CodigoErro,mensagem, resourceKey, itens);
                
            }
		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarBolsa()
		/// </summary>
		private bool ValidarBolsa()
        {
            if (!string.IsNullOrEmpty(EntityToValidate.CodigoBolsa))
            {
                if (
                    new Ordens.BusinessLogic.Bolsa().ConsultarBolsaCodigo(
                    new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Bolsa() { Codigo = EntityToValidate.CodigoBolsa }) == null
                    )
                {
                    base.AddValidationError(109266);
                }
            }
            else
            {
                string bolsa;
                if (string.IsNullOrEmpty(bolsa = new Operador.BusinessLogic.Operador().ObterPreferencias(AuthorizationContext.Current.UserId).Bolsa))
                {
                    EntityToValidate.CodigoBolsa = bolsa;
                }
                else
                {
                    EntityToValidate.CodigoBolsa = "1";
                }
            }

            return base.ErrorsList.Count == 0;

		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarCarteira()
		/// </summary>
		private bool ValidarCarteira()
        {
            if (
                (EntityToValidate.TipoOrdem.HasValue)
                && 
                (EntityToValidate.TipoOrdem.Value != Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoOrdem.Financiamento)
               )
            {
                if (EntityToValidate.CodigoBolsa == "1" && EntityToValidate.CodigoISIN.Substring(6, 2).ToUpper() == "PP")
                {
                    EntityToValidate.Carteira = 277;
                }
                else
                {
                    if (!EntityToValidate.Carteira.HasValue)
                    {
                        Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Parameter.ConsultarMenorCarteira param =
                            new Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Parameter.ConsultarMenorCarteira();

                        param.CodigoBolsa = EntityToValidate.CodigoBolsa;

                        switch (EntityToValidate.Mercado)
                        {
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Vista:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Vista;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoCompra:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.OpcaoCompra;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoVenda:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.OpcaoVenda;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Fracionario:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Fracionario;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Estruturado:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Estruturado;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Leilao:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Leilao;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Termo:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Termo;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Futuro:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Futuro;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.VencimentoFuturo;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.BOX:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.BOX;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.CotasETF:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.CotasETF;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas;
                                break;
                        }

                        if (EntityToValidate.NaturezaOperacao == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao.Compra)
                            param.NaturezaOperacao = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoNaturezaOperacao.Compra;
                        else
                            param.NaturezaOperacao = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoNaturezaOperacao.Venda;

                        Carteira.BusinessEntity.Carteira carteira = new Carteira.BusinessLogic.Carteira().ConsultarMenorCarteira(param);
                        if (carteira != null)
                            EntityToValidate.Carteira = (short?)carteira.CodigoCarteira;
                    }
                    else
                    { 
                        Carteira.BusinessEntity.Parameter.ValidarCarteiraMercado param = new Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Parameter.ValidarCarteiraMercado();

                        param.CodigoBolsa = EntityToValidate.CodigoBolsa;
                        param.CodigoCarteira = (int)EntityToValidate.Carteira;

                        switch (EntityToValidate.Mercado)
                        {
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Vista:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Vista;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoCompra:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.OpcaoCompra;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoVenda:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.OpcaoVenda;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Fracionario:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Fracionario;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Estruturado:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Estruturado;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Leilao:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Leilao;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Termo:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Termo;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Futuro:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.Futuro;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.VencimentoFuturo;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.BOX:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.BOX;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.CotasETF:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.CotasETF;
                                break;
                            case Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas:
                                param.CodigoMercado = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas;
                                break;
                        }

                        if (EntityToValidate.NaturezaOperacao == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao.Compra)
                            param.NaturezaOperacao = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoNaturezaOperacao.Compra;
                        else
                            param.NaturezaOperacao = Sinacor.Servico.Bovespa.Carteira.BusinessEntity.Enum.TipoNaturezaOperacao.Venda;

                        if (!new Carteira.BusinessLogic.Carteira().ValidarCarteiraMercado(param))
                            base.AddValidationError(109271);

                    }
                }
            }
            return base.ErrorsList.Count == 0;
        }

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarCliente()
		/// </summary>
		private bool ValidarCliente()
        {
            if (!EntityToValidate.CodigoCliente.HasValue)
            {
                base.AddValidationError(109253);
            }
            else
            {
                //Obter Dados do Cliente da Ordem
                _cliente = new Sinacor.Servico.Bovespa.Cliente.BusinessLogic.Cliente().ObterCliente
                    (new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.FiltroCliente() { Codigo = EntityToValidate.CodigoCliente });

                if (_cliente == null)
                {
                    base.AddValidationError(109254);
                }
                else
                {
                    if (_cliente.Situacao == Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoSituacao.Inativo)
                    {
                        base.AddValidationError(109254);
                    }
                    else
                    {
                        EntityToValidate.CodigoBrokerCliente = _cliente.CodigoClienteBroker;
                        EntityToValidate.IndicadorClientePessoaVinculada = _cliente.isPessoaVinculada;

                        if (_cliente.TipoPessoa == Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoPessoa.Juridica)
                        {
                            if (string.IsNullOrEmpty(EntityToValidate.NomeEmissor))
                            {
                                EntityToValidate.NomeEmissor =
                                    new Bovespa.Cliente.BusinessLogic.Cliente().ObterEmissorPrincipal(
                                    new Bovespa.Cliente.BusinessEntity.Parameter.FiltroCodigoCliente() { Codigo = _cliente.Codigo.Value }).NomeEmissor;

                            }
                        }
                        if (new Parametro.BusinessLogic.Parametro().ObterParametro().IndicadorDigitoCliente == "S")
                        {
                            if (!EntityToValidate.DigitoCliente.HasValue)
                            {
                                base.AddValidationError(109488);
                            }
                            else
                            {
                                if (EntityToValidate.DigitoCliente != _cliente.Digito)
                                {
                                    base.AddValidationError(109254);
                                }
                            }
                        }
                        else
                        {
                            if(
                                _cliente.IsAdministradoConcorrente &&
                                
                                new Bovespa.Cliente.BusinessLogic.TipoConta().ConsultarTiposConta(
                                new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.FiltroTipoConta()
                                { CodigoCliente = _cliente.Codigo.Value }
                                ).FindAll
                                (delegate(Bovespa.Cliente.BusinessEntity.TipoConta conta) 
                                    {
                                        return conta.TipoCliente == Bovespa.Cliente.BusinessEntity.Enum.TipoCliente.AdministradoConcorrente;
                                    }
                                ).Count != 0
                                
                                )
                            {
                                EntityToValidate.IndicadorOrdemAdmConcorrente = true;
                            }
                            else
                            {
                                EntityToValidate.IndicadorOrdemAdmConcorrente = false;
                            }

                            if (new Parametro.BusinessLogic.Parametro().ObterParametro().BloqueioClientes)
                            {
                                BusinessEntity.Resultado result = null;

                                //Validar se cliente da Ordem está bloqueado
                                if (EntityToValidate.DataValidade
                                    < _informacoesMovimento.DataMovimento)
                                {
                                    result = new ResourceAccess.ManutencaoOrdens().VerificarClienteBloqueado(EntityToValidate, BusinessEntity.Enum.TipoValidacaoClienteBloqueado.PorDataValidade);
                                }
                                else
                                {
                                    result = new ResourceAccess.ManutencaoOrdens().VerificarClienteBloqueado(EntityToValidate, BusinessEntity.Enum.TipoValidacaoClienteBloqueado.PorDataPregao);
                                }

                                if (!result.Sucesso)
                                {
                                    if (result.CodigoErro == -1)
                                    {
                                        base.AddValidationError(109414);
                                    }
                                    else
                                    {
                                        this.TratarExcecoes(result);
                                    }
                                }

                            }
                        }
                    }
                }

            }

            return base.ErrorsList.Count == 0;
        }

            

            
		

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarDataValidade()
		/// </summary>
		private bool ValidarDataValidade()
        {
            if (EntityToValidate.DataValidade.HasValue)
            {
                if (EntityToValidate.DataValidade.Value < _informacoesMovimento.DataMovimento)
                {
                    base.AddValidationError(109280);
                }
            }
            else
            {
                EntityToValidate.DataValidade = _informacoesMovimento.DataMovimento;
            }

            return base.ErrorsList.Count == 0;

		}

		/// <summary>
		/// <b>Se</b> request.ValorDolar igual a nulo
		///   Assumir entityToValidate.ValorDolar = 1
		/// <b>Senão</b>
		///   <b>Se</b> entityToValidate.ValorDolar &lt; 0 (zero)
		/// base.AddValidationError(109273)
		/// <b>   Fim Se</b>
		/// <b>Fim Se</b>
		/// 
		/// <b>Obs:. </b>Caso gere uma exception, retornar falso senão retornar verdadeiro
		/// </summary>
		private bool ValidarDolar()
        {
            if (!EntityToValidate.ValorDolar.HasValue)
            {
                EntityToValidate.ValorDolar = 1;
            }
            else
            {
                if (EntityToValidate.ValorDolar.Value <= 0)
                {
                    base.AddValidationError(109273);
                }
            }

            return base.ErrorsList.Count == 0;

		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarMercado()
		/// </summary>
		private bool ValidarMercado()
        {
            if (EntityToValidate.Mercado == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.CotasETF 
                || EntityToValidate.Mercado == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas)
            {
                if (EntityToValidate.Discricionaria)
                {
                    base.AddValidationError(109413);
                }
            }
            else
            {
                if (EntityToValidate.TipoOrdem.Value != BusinessEntity.Enum.TipoOrdem.Financiamento &&
                    EntityToValidate.Mercado == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Termo)
                {
                    //Termo Secundário: Parte numérica do Código de Negociação 
                    //(entityToValidate.Ativo) do Ativo informado deve ser maior que 50. Ex.: PETR51T - '51' indica Termo Secundário
                    //A letra 'T' no código do ativo, no exemplo acima, indica que é Termo.

                    string ativo = EntityToValidate.Ativo;

                    int indicadorTermo = ativo.ToUpper().LastIndexOf("T");
                    int firstDigit = indicadorTermo;
                    int exit = 0;
                    string MyNumber = string.Empty;

                    if (indicadorTermo != 0 && indicadorTermo != -1)
                    {
                        do { firstDigit--; }
                        while (Int32.TryParse(ativo[firstDigit].ToString(), out exit));
                        firstDigit++;
                        for (int i = firstDigit; i < indicadorTermo; i++)
                        {MyNumber += ativo[i];}
                    }

                    if (Int32.TryParse(MyNumber, out exit) && exit > 50)
                    {
                        EntityToValidate.PrazoVencimentoTermo = null;
                    }
                    else
                    { 
                        if(!EntityToValidate.PrazoVencimentoTermo.HasValue 
                            || EntityToValidate.PrazoVencimentoTermo.Value <= 0)
                        {
                            base.AddValidationError(109249);
                        }
                    }

                }
                else
                {
                    EntityToValidate.PrazoVencimentoTermo = null;
                }
            }

            return base.ErrorsList.Count == 0;

		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarOperador()
		/// </summary>
		private bool ValidarOperador()
        {
            List<Usuario.BusinessEntity.Usuario> lstUsu = null;
            List<Operador.BusinessEntity.Operador> lstOp = null;
            List<Operador.BusinessEntity.Operador> lstOpEnt = null;

            if ((lstOp = new Operador.BusinessLogic.Operador().ConsultarOperadores(new Sinacor.Servico.Bovespa.Operador.BusinessEntity.Parameter.FiltroOperador() { CodigoOperador = AuthorizationContext.Current.UserId })).Count == 0)
            {
                base.AddValidationError(109277);
            }
            else//é operador
            {
                if (!lstOp[0].IndicadorPontaMesa.Value)
                {
                    EntityToValidate.CodigoOperador = AuthorizationContext.Current.UserId;

                    lstUsu = new Usuario.BusinessLogic.Usuario().ConsultarUsuarios(new Sinacor.Servico.Bovespa.Usuario.BusinessEntity.Parameter.FiltroUsuario() { Codigo = EntityToValidate.CodigoOperador, Operador = true });

                    if (lstUsu.Count != 0 && lstUsu[0].Bloqueado.Value)
                    {
                        base.AddValidationError(109279);
                    }
                }
                else
                {
                    if (EntityToValidate.CodigoOperador != AuthorizationContext.Current.UserId)
                    {
                        if ((lstOpEnt = new Operador.BusinessLogic.Operador().ConsultarOperadores(new Sinacor.Servico.Bovespa.Operador.BusinessEntity.Parameter.FiltroOperador() { CodigoOperador = EntityToValidate.CodigoOperador })).Count == 0)
                        {
                            base.AddValidationError(109277);
                        }
                        else
                        {
                            lstUsu = new Usuario.BusinessLogic.Usuario().ConsultarUsuarios(new Sinacor.Servico.Bovespa.Usuario.BusinessEntity.Parameter.FiltroUsuario() { Codigo = EntityToValidate.CodigoOperador, Operador = true });

                            if (lstUsu.Count != 0 && lstUsu[0].Bloqueado.Value)
                            {
                                base.AddValidationError(109279);
                            }
                        }

                    }
                    else
                    {
                        lstUsu = new Usuario.BusinessLogic.Usuario().ConsultarUsuarios(new Sinacor.Servico.Bovespa.Usuario.BusinessEntity.Parameter.FiltroUsuario() { Codigo = EntityToValidate.CodigoOperador, Operador = true });

                        if (lstUsu.Count != 0 && lstUsu[0].Bloqueado.Value)
                        {
                            base.AddValidationError(109279);
                        }
                    }
                }
            }
            return base.ErrorsList.Count == 0;
		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarPreco()
		/// </summary>
		private bool ValidarPreco()
        {
            if ((EntityToValidate.TipoOrdem.HasValue) &&
                (EntityToValidate.TipoOrdem.Value == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoOrdem.Limitada ||
                EntityToValidate.TipoOrdem.Value == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoOrdem.OnStop))
            {
                if (!EntityToValidate.Preco.HasValue || (EntityToValidate.Preco.HasValue && EntityToValidate.Preco <= 0))
                {
                    base.AddValidationError(109268);
                }
            }
            else
            {
                EntityToValidate.Preco = 0;
            }

            return base.ErrorsList.Count == 0;

		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarQuantidade()
		/// </summary>
		private bool ValidarQuantidade()
        {
            bool TipoOrdemInformado = EntityToValidate.TipoOrdem.HasValue;
            bool naoFinanciamento = TipoOrdemInformado && (EntityToValidate.TipoOrdem.Value != Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoOrdem.Financiamento);

            if (!TipoOrdemInformado || naoFinanciamento)
            {
                if (EntityToValidate.Quantidade <= 0)
                {
                    base.AddValidationError(109272);
                }
                else
                { 
                    Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Parameter.ConsultarLoteMinimoNegociacao param 
                        = new Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Parameter.ConsultarLoteMinimoNegociacao();

                    param._Titulo = EntityToValidate.Ativo;

                    param._DataPregao = _informacoesMovimento.DataMovimento;

                    int? retorno = new Titulo.BusinessLogic.Titulo().ConsultarLoteMinimoNegociacao(param);

                    if (retorno == 0) retorno = 1;

                    if (EntityToValidate.Quantidade % retorno != 0)
                    {
                        base.AddValidationError(109312);
                    }

                    if (!EntityToValidate.QuantidadeAnexoIV.HasValue)
                    {
                        EntityToValidate.QuantidadeAnexoIV = 0;
                    }
                    else
                    {
                        if (EntityToValidate.QuantidadeAnexoIV < 0)
                        {
                            base.AddValidationError(109313);
                        }
                    }

                    if (!EntityToValidate.QuantidadeAnexoV.HasValue)
                    {
                        EntityToValidate.QuantidadeAnexoV = 0;
                    }
                    else
                    {
                        if (EntityToValidate.QuantidadeAnexoV < 0)
                        {
                            base.AddValidationError(109314);
                        }
                    }

                    if (EntityToValidate.QuantidadeAnexoIV + EntityToValidate.QuantidadeAnexoV > EntityToValidate.Quantidade)
                    {
                        base.AddValidationError(109315);
                    }

                }
            }

			return base.ErrorsList.Count == 0;
		}

		/// <summary>
		/// Verificar diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// ValidarTipoOrdemFinanciamento()
		/// </summary>
		private void ValidarTipoOrdemFinanciamento()
        {
            if (EntityToValidate.Quantidade != 0)
            {
                base.AddValidationError(109412);
            }
                else
                {
                    if (!(EntityToValidate.PercentualFinanciamento >= 0 && EntityToValidate.PercentualFinanciamento <= 100))
                    {
                        base.AddValidationError(109274);
                    }
                        else
                        {
                            if (!EntityToValidate.ValorFinanciamento.HasValue)
                            {
                                base.AddValidationError(109275);
                            }
                                else
                                {
                                    if (EntityToValidate.ValorFinanciamento < 0)
                                    {
                                        base.AddValidationError(109275);
                                    }
                                        else
                                        {
                                            if (base.ErrorsList.Count == 0)
                                            {
                                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Termo;
                                                EntityToValidate.NaturezaOperacao = null;
                                                EntityToValidate.Carteira = 0;
                                                EntityToValidate.Quantidade = 0;
                                                EntityToValidate.QuantidadeAnexoIV = 0;
                                                EntityToValidate.QuantidadeAnexoV = 0;
                                            }
                                        }
                                }
                        }
                }
		}

		/// <summary>
		/// Verificar o diagrama de atividade BusinessRuleValidation/ValidadorInclusaoOrdem.
		/// Validate()
		/// </summary>
        public void Validate()
        {
            _informacoesMovimento = new Movimento.BusinessLogic.ControleMovimentoOrdens().ObterInformacoesMovimento(
                new Sinacor.Servico.Bovespa.Movimento.BusinessEntity.DataMovimento()
                );

            if (this.ValidarNaturezaOperacao())
            {
                if (this.ValidarAtivo())
                {
                    if (EntityToValidate.TipoOrdem == BusinessEntity.Enum.TipoOrdem.Financiamento)
                    {
                        this.ValidarTipoOrdemFinanciamento();
                    }


                    if (this.ErrorsList.Count == 0 && this.ValidarMercado())
                    {
                        if (this.ValidarCliente())
                        {
                            if (!EntityToValidate.TipoLiquidacao.HasValue)
                            {
                                this.ConfigurarTipoLiquidacao();
                            }

                            this.ConfigurarTipoDistribuicao();

                            if (this.ValidarBolsa())
                            {
                                if (this.ValidarPreco())
                                {
                                    if (this.ValidarCarteira())
                                    {
                                        if (this.ValidarQuantidade())
                                        {
                                            if (this.ValidarDolar())
                                            {
                                                if (this.ValidarOperador())
                                                {
                                                    if (this.ValidarDataValidade())
                                                    {
                                                        this.ConfigurarOrdem();
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        private bool ValidarNaturezaOperacao()
        {
            if (EntityToValidate.TipoOrdem.Value != BusinessEntity.Enum.TipoOrdem.Financiamento)
            {
                if (!EntityToValidate.NaturezaOperacao.HasValue || EntityToValidate.NaturezaOperacao.Value == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.NaturezaOperacao.CompraVenda)
                {
                    base.AddValidationError(109594);
                }
            }

            return ErrorsList.Count == 0;
        }

        /// <summary>
        /// ValidarAtivo
        /// </summary>
        /// <returns></returns>
        private bool ValidarAtivo()
        {
            if (
                (EntityToValidate.TipoOrdem.HasValue)
                && 
                (EntityToValidate.TipoOrdem.Value == Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                )
            {
                EntityToValidate.Ativo = null;
                EntityToValidate.CodigoISIN = null;
                EntityToValidate.CodigoCasamento = null;
            }
            else
            {
                if (string.IsNullOrEmpty(EntityToValidate.Ativo))
                {
                    base.AddValidationError(109258);
                }
                else
                {
                    Titulo.BusinessEntity.Titulo param = new Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Titulo();

                    param.DataOrdem = (EntityToValidate.DataOrdem == DateTime.MinValue) ? _informacoesMovimento.DataMovimento : EntityToValidate.DataOrdem;
                    param.Codigo = EntityToValidate.Ativo;

                    _ativo = new Titulo.BusinessLogic.Titulo().ObterTitulo(param);

                    if (string.IsNullOrEmpty(_ativo.Codigo))
                    {
                        base.AddValidationError(109252);
                    }
                    else
                    {
                        EntityToValidate.CodigoISIN = _ativo.CodigoISIN;
                        
                        switch (_ativo.TipoMercado.Value)
                        {
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.BOX:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.BOX;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.CotasETF:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.CotasETF;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.Estruturado:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Estruturado;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra:
                                EntityToValidate.Mercado = Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.Fracionario:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Fracionario;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.Futuro:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Futuro;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.IntegralizacaoResgateCotas;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.Leilao:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Leilao;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.OpcaoCompra:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoCompra;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.OpcaoVenda:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.OpcaoVenda;
                                break;                            
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.Termo:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Termo;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.VencimentoFuturo:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo;
                                break;
                            case Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado.Vista:
                                EntityToValidate.Mercado = Sinacor.Servico.Bovespa.ManutencaoOrdens.BusinessEntity.Enum.TipoMercado.Vista;
                                break;                            
                        }

                        BusinessEntity.Resultado result = null;

                        result = new ResourceAccess.ManutencaoOrdens().GerarCodigoCasamento(EntityToValidate);

                        if (!result.Sucesso)
                        {
                            if (result.CodigoErro == -1)
                            {
                                base.AddValidationError(109281);
                            }
                            else
                            {
                                this.TratarExcecoes(result);
                            }
                        }
                        else
                        {
                            EntityToValidate.CodigoCasamento = result.Valor.ToString();
                        }
                    }

                }
            }

            return base.ErrorsList.Count == 0;
        }

        #endregion

    }
}